
package futbol.tacticas.concursantes2007.Eugenio;
import futbol.Futbol;
import futbol.General;
import futbol.tacticas.concursantes.Tactica;

import java.awt.*;
import java.util.Vector;
import futbol.tacticas.*;
/**
 *
 * @author Administrador
 */
public class TacticaEugenio implements Tactica{
    
    private int nValoresDefensa[][]={
        {-155,  0},  // Jugador  1[ 0]
        {-100,-60},  // Jugador  2[ 1]
        {-100,  0},  // Jugador  3[ 2]
        {-100, 60},  // Jugador  4[ 3]
        { -70,-40},  // Jugador  5[ 4]
        { -70, 40},  // Jugador  6[ 5]
        {  10,-40},  // Jugador  7[ 6]
        {  10, 40},  // Jugador  8[ 7]
        {  60,-60},  // Jugador  9[ 8]
        {  60,  0},  // Jugador 10[ 9]
        {  60, 60}   // Jugador 11[10]
    };
    
    private int nValoresMedio[][]={
        {-145,  0,5},  // Jugador  1[ 0]
        { -90,-60,6},  // Jugador  2[ 1]
        { -90,  0,6},  // Jugador  3[ 2]
        { -90, 60,6},  // Jugador  4[ 3]
        { -40,-40,6},  // Jugador  5[ 4]
        { -40, 40,6},  // Jugador  6[ 5]
        {  40,-40,7},  // Jugador  7[ 6]
        {  40, 40,7},  // Jugador  8[ 7]
        {  80,-60,7},  // Jugador  9[ 8]
        {  80,  0,7},  // Jugador 10[ 9]
        {  80, 60,7}   // Jugador 11[10]
    };

    private int nValoresAtaque[][]={
        {-135,  0},  // Jugador  1[ 0]
        { -80,-60},  // Jugador  2[ 1]
        { -80,  0},  // Jugador  3[ 2]
        { -80, 60},  // Jugador  4[ 3]
        { -10,-40},  // Jugador  5[ 4]
        { -10, 40},  // Jugador  6[ 5]
        {  70,-40},  // Jugador  7[ 6]
        {  70, 40},  // Jugador  8[ 7]
        { 100,-60},  // Jugador  9[ 8]
        { 100,  0},  // Jugador 10[ 9]
        { 100, 60}   // Jugador 11[10]
    };
    static final int LONGTRAY = 180;
    
    public Color getColor1() {
        return Color.DARK_GRAY;
    }

    public Color getColor2() {
        return Color.BLACK;
    }

    public Color getColorNumero() {
        return Color.white;
    }

    public String getNombre() {
        return "Eugenio";
    }

    public int getXInicial(int n) {
        return nValoresMedio[n][0];
    }

    public int getYInicial(int n) {
        return nValoresMedio[n][1];
    }

    public int getFuerza(int n) {
        return nValoresMedio[n][2];
    }

    public Vector<Comando> getComandos(SituacionJugadores sj) {
        Vector<Comando> com=new Vector();

        Point bola=sj.getBola();
        Point jugadores[]=sj.getMisJugadores();
        Point contrarios[]=sj.getContrario();

        //Posicionamiento
        if(bola.x<-100){
        	for (int n=1;n<11;n++)
        		com.add(new ComandoIrA(n,nValoresDefensa[n][0],nValoresDefensa[n][1]));
        }
        else if (bola.x<100){
        	for (int n=1;n<11;n++)
        		com.add(new ComandoIrA(n,nValoresMedio[n][0],nValoresMedio[n][1]));
        }
        else {
        	for (int n=1;n<11;n++)
        		com.add(new ComandoIrA(n,nValoresAtaque[n][0],nValoresAtaque[n][1]));
        }
        
        //Mejorar defensa
        
        // Falta que no cubran dos a un delatero
        if (!sj.estoyMasCercaDeBola() || bola.getX()<0){
            for (int n=1;n<4;n++){
                int nJC=sj.getContrarioMasCerca(getXInicial(n), getYInicial(n));
                if(sj.getMiJugadorMasCerca(contrarios[nJC].x,contrarios[nJC].y)== n){
                	//com.add(new ComandoIrA(n, contrarios[nJC].getX()+20, contrarios[nJC].getY()));
                	double py = contrarios[nJC].y+(20*Math.tan(General.getAngulo(contrarios[nJC].x,contrarios[nJC].y, bola.x, bola.y)));
                	com.add(new ComandoIrA(n, contrarios[nJC].getX()+20, py));
                }
            }
        }

        //Movimiento portero
        if(bola.x<-100){
            double y=0;
            double ang = Math.tan(General.getAngulo(nValoresDefensa[0][0],0, bola.x, bola.y));
            if (ang!=0) y = 20*ang;

            com.add(new ComandoIrA(0,nValoresDefensa[0][0], y));
        }
        else if (bola.x<100){
            double y=0;
            double ang = Math.tan(General.getAngulo(nValoresMedio[0][0],0, bola.x, bola.y));
            if (ang!=0) y = 20*ang;

            com.add(new ComandoIrA(0,nValoresMedio[0][0], y));
        }
        else {
            double y=0;
            double ang = Math.tan(General.getAngulo(nValoresAtaque[0][0],0, bola.x, bola.y));
            if (ang!=0) y = 20*ang;

            com.add(new ComandoIrA(0,nValoresAtaque[0][0], y));
        }
        
        //Movimiento mas cercano a la bola
        int nJug=sj.getMasCercanoDeBola();
        com.add(new ComandoIrA(nJug,bola.getX(), bola.getY()));

        MejorPase(sj, com);
        
        return com;
    }

    private void MejorPase(SituacionJugadores sj, Vector<Comando> com){
        Point bola=sj.getBola();
        Point miEquipo[]=sj.getMisJugadores();
        for (int n=0;n<11;n++){
        	//Comprueba si tien posibilidades remotas de chutar 
        	if (General.getDistancia(miEquipo[n].x, miEquipo[n].y, bola.x, bola.y)>30)
        		continue;
        	Point coordenadas = new Point(CoordenadasChute(miEquipo[n],sj));
        	com.add(new ComandoGolpearBola(n,coordenadas.x,coordenadas.y));
        }
    }
    
    private Point[] trayectoriaTiro(Point p, double angulo){
    	
    	Point [] trayectoria = new Point[LONGTRAY];
    	double dx =0; double dy =0;
    	int i=0;

    	dx = p.getX();
    	dy = p.getY();
    	
    	while ((dx < 160) && (i<LONGTRAY)) {
    		
            dx+=Math.cos(angulo);
            dy+=Math.sin(angulo);
            
            if (dy<-120){
            	dy=-120;
            	angulo=-angulo;
            }
            if (dy>120){
            	dy=120;
            	angulo=-angulo;
            }
            
            trayectoria[i++]= new Point((int)dx,(int)dy);
    	}
    	
    	return trayectoria;
    }
    
    
    
    private double ValoraTiro(Point p, double angulo,SituacionJugadores sj){
    	
    	int valor=0;
        Point miEquipo[]=sj.getMisJugadores();
        Point contrario[]=sj.getContrario();

        Point [] trayectoria;
        trayectoria=trayectoriaTiro(p,angulo);
        Point fp = new Point(0,0);
        Point pp = new Point(0,0);
        
        for(int i=0;i<LONGTRAY;i++){
        	
        	if(trayectoria[i] == null) break;
        	
        	fp=trayectoria[i];
        	
        	//A gol
        	if(fp.x==160 && fp.y>-30 && fp.y<30){
        		valor+=10000000;
        		valor+=1000-General.getDistancia(p.x,p.y,fp.x,fp.y);
        		valor+=100+Math.abs(fp.y-contrario[0].y);
        		break;
        	}
        	
        	//Pase a jugador
        	for(int j=0;j<11;j++){
        		pp.x=miEquipo[j].x;
        		pp.y=miEquipo[j].y;
        		if(fp.x==pp.x && Math.abs(fp.y-pp.y)<10){
        			if(pp.x<160 && pp.x>=120) valor+=1000000;
        			if(pp.x<120 && pp.x>=80) valor+=100000;
        			if(pp.x<80 && pp.x>=40) valor+=10000;
        			if(pp.x<40 && pp.x>=0) valor+=1000;
        			if(pp.x<0 && pp.x>=-80) valor+=100;
        			if(pp.x<-80 && pp.x>=-160) valor+=10;
        			valor+=General.getDistancia(p.x,p.y,pp.x,pp.y);
        			break;
        		}
        	}
        	
        	//Intercepcion
        	for(int j=0;j<11;j++){
        		pp.x=contrario[j].x;
        		pp.y=contrario[j].y;
        		if(fp.x==pp.x && fp.y==pp.y){
        			valor+=-10000;
        			valor+=General.getDistancia(fp.x,fp.y,pp.x,pp.y);
        			break;
        		}
        	}
        }
        
        if(valor==0){
        	valor+=General.getDistancia(p.x, p.y, fp.x, fp.y);
        }

        return valor;
    	
    }
    
    private double MejorAngulo(Point p, SituacionJugadores sj){
    	double valor=0;
    	double mejorValor=0;
    	double mejorAngulo=0;
    	
    	for(double i=-0.8;i<0.8;i+=0.05){
    		valor = ValoraTiro(p,i,sj);
    		if (valor>mejorValor){
    			mejorValor=valor;
    			mejorAngulo=i;
    		}
    	}
    	
    	return mejorAngulo;
    }

    
    // Acaba nuevo
    // Ajuste por no poder usar el angulo
    
    private Point CoordenadasChute(Point p, SituacionJugadores sj){
    	
    	Point coordenadas;
    	double angulo = MejorAngulo(p,sj);
    	
    	
    	double dx =0; double dy =0;
    	int i=0;

    	dx = p.getX();
    	dy = p.getY();
    	
    	while ((dx < 160) && (i<LONGTRAY)) {
    		
            dx+=Math.cos(angulo);
            dy+=Math.sin(angulo);
            
            if ((dy<-120) || (dy>120)){
            	break;
            }
            
    	}
    	
    	//Ajuste por el angulo aleatorio en el tiro a gol
    	if (dx==160){
    		if (dy<0) dy+=5;
    		if (dy>0) dy-=5;
    	}

    	coordenadas = new Point((int)dx,(int)dy);
    	
    	return coordenadas;
    }
    
}
